Auch auf die Sperren möchte ich noch einmal zurückkommen und hier insbesondere zunächst

die Unterbrechungssperre. Wir hatten ja zum Anfang gezeigt, dass man diesen First-Level-Interrupt-Händler

recht einfach sperren können, indem man einfach die Spezialbefehle dafür verwendet,

eines Prozessors, nämlich um Interrupts zu disablen und den am Ende wieder herzustellen.

Ich habe ja darauf hingewiesen, dass es durchaus anders geschehen muss, wenn man dann

verschachtelte kritische Abschnitte vor sich findet. Und das wollen wir uns jetzt mal anschauen,

wie denn praktisch so eine Befehlsfolgen denn in so einem Fall denn aussehen würden konkret

jetzt für ein x86. Da haben wir unsere Enter- und Leave-Operationen nun wie zuvor eben auch mit

Inline Assembler arbeitet man hier. Man muss ja aus der Hochsprache kommend halt eben besondere

Befehle eben absetzen, die dann zur Ausführung kommen können, um dann so eine Unterbrechungssperre

denn abzusetzen. Also diese besonderen Befehle sind das CLI, normalerweise gibt es dafür kein

Hochsprachen-Äquivalent und das STI etwa. Um jetzt hier die Verschachtelung durchzuführen,

da würde man praktisch entsprechend beim Enter wie folgt vorgehen, dass wenn man eine Verschachtelung

wünscht, also wenn sozusagen hier ein Zeiger für eine Variable, für ein Objekt gegeben ist, wohin

man praktisch einen Zustand sichern kann, nämlich der Synchronisationszustand, der in dem Moment

dieser Enter-Operation gilt, dann würde man praktisch das Flagsregister sichern. Das kann man

beim x86 praktisch wie folgt machen, man legt es einfach auf den Stack ab, dann holt man sich das

Objekt vom Stack runter und mit dieser Anweisung sorgt dafür, dass dann praktisch dieses Objekt

vom Stack an diese Stelle dann praktisch hin gespeichert wird. Also konkret jetzt ins Flags-Attribut

von diesem Detent-Objekt letztendlich. Und wenn man denn diese Sicherung durchgeführt hat, dann

kann man auch die Interrupts disablen. In dem Moment würde man mit CLI eben den Eintrag in

dem Flagsregister, wo dieses Interrupt-Flag praktisch von der CPU gespeichert ist, denn verändern

und letztendlich auf Null setzen. Dieses Interrupt-Bit beim x86, wenn es Null ist im Flagsregister,

heißt es, die CPU nimmt keine Unterbrechungsanforderungen an und wenn dieses Bit auf 1

gesetzt ist, das wird nämlich durch das STI auf 1 gesetzt, dann wird die CPU in der Lage sein, auch

so eine Unterbrechungsanforderung halt abzusetzen. Also das wäre jetzt beim Enter die Maßnahme, um

praktisch, wenn man geschachtete kritische Abschnitte zu haben, immer für die jeweilige

Betrachtungsebene den Interrupt-Disable-Zustand zu speichern, abzusichern, der jetzt gerade in dem

Moment gilt, wo man praktisch die Interrupt-Sperre erheben möchte. Bei der Leaf-Operation macht man

jetzt das inverse. Wenn man jetzt sozusagen praktisch mit so einem Objekt überarbeitet,

unterstellen wir jetzt mal, dann kommt jetzt hier in der Leaf-Operation der Zeige auf so ein

Sicherungsobjekt runter, denn würde also der Zeige immer definiert sein. Ja, dann holen wir

schlichtweg praktisch aus diesem Attribut, aus diesem Nest-Flex hier mit dieser ersten Anweisung

unseren gesicherten Zustand raus, legen den auf den Stapelspeicher ab und holen praktisch von dem

Top-of-Stack den Wert runter und legen ihn dann halt mit Pop-Flex ins Flex-Register ab. Und so würden

wir dann halt immer den zuvor mit Enter gesicherten Zustand dann sozusagen halt hier unten in der

Leaf-Operation denn wieder herstellen. Man würde normalerweise, wenn man also jetzt mit solchen

Objekten arbeitet, dieses STI hier in der Leaf-Operation niemals machen, sondern implizit,

wenn man mit Pop-Flex einen Flex-Registerzustand praktisch vom Stapelspeicher liest,

wo eben denn das Interrupt-Bit auf 1 gesetzt ist, hat man damit implizit einen Zustand gelesen,

der der CPU anzeigt, Unterbrechungsanforderungen halt anzunehmen. Sehr, also ein relativ einfacher

Mechanismus, um jetzt verschachtelungsfähige kritische Abschnitte auf Basis von Interrupt-Sperren,

Unterbrechungssperren, denn zu formulieren. Dann möchte ich nochmal in die wieder Eintrittssperre

halt zu sprechen kommen. Da ging es ja im Wesentlichen darum, diese Second-Level-Interrupt-Händler

halt zu sperren letztendlich. Aber ich hatte eben auch gesagt, dass das letztendlich daraus

hinauswopft, dass man so was wie Prozeduraufrufe denn zurückstellt. Ja, das heißt also eigentlich

man Objekte denn vor sich hat, die dann Prozeduraufrufe repräsentieren würden. Und wenn diese Prozeduraufrufe

aber aufgrund gewisser Asynchron-Aktivitäten denn jetzt nicht zulässig sind, dann will man die

zurückstellen, dann würde man diese Objekte einkühen und am Ende, wenn man denn weiß,

dass der Zustand sicher ist, dass man praktisch diese zurückgestellten Prozeduraufrufe abarbeiten